\section{NAME\label{NAME}\index{NAME}}


Bench::Test::Remote - Automatiza ejecuciones en maquinas remotas

\section{SYNOPSIS\label{SYNOPSIS}\index{SYNOPSIS}}
\begin{verbatim}
   my $remote = Bench::Test::Remote->new(
      HOST       => 'user@some.host.com',
      WORKDIR    => '/home/user/mm',
      EXECUTABLE => 'mm',
      BASEDIR    => './base_somehost',
      OUTPUTFILE => 'output.dat',
      PREAMBLE   => sub {
         my $machine = shift;
         $machine->put(['mm.tar.gz']);
         $machine->system('tar xfz mm.tar.gz');
         $machine->chdir('mm');
         $machine->system('make');
      },
      POSTAMBLE  => sub {
         my $machine = shift;
         $machine->chdir('..');
         $machine->system('rm -rf mm');
         $machine->system('rm mm.tar.gz');
      },
   );
\end{verbatim}
\begin{verbatim}
   my $parameters = ...
   my $output = $remote->get_result($parameters);
\end{verbatim}
\begin{verbatim}
   $remote->save_result($parameters, $testname);
\end{verbatim}
\section{DESCRIPTION\label{DESCRIPTION}\index{DESCRIPTION}}


El objeto Bench::Test::Remote permite ecapsular las operaciones
de ejecucion de programas en maquinas remotas. Dispone de dos
metodos que permiten obtener la salida de la ejecucion o almacenarla
respectivamente: \texttt{get\_result} y \texttt{save\_result}.



El objeto Bench::Test hace uso del modulo GRID::Machine implementado
por Casiano Rodriguez.

\subsection*{Example\label{Example}\index{Example}}


Supongamos un programa cuya salida sea la siguiente:

\begin{verbatim}
  user@some.host.com:~/projects/Bench-Test/examples/mm$ ./mm dat/mm_200.dat 
  Filas primera matriz: 200
  Filas segunda matriz: 200
  Columnas segunda matriz: 200
  Time of product: 0.210942
  Result: 4102
\end{verbatim}


Creamos un objeto \texttt{Bench::Test::Remote} de la siguiente forma:

\begin{verbatim}
   my $remote = Bench::Test::Remote->new(
      HOST       => 'user@some.host.com',
      WORKDIR    => '/home/user/mm',
      EXECUTABLE => 'mm',
      BASEDIR    => './base_somehost',
      OUTPUTFILE => 'output.dat',
      PREAMBLE   => sub {
         my $machine = shift;
         $machine->put(['mm.tar.gz']);
         $machine->system('tar xfz mm.tar.gz');
         $machine->chdir('mm');
         $machine->system('make');
      },
      POSTAMBLE  => sub {
         my $machine = shift;
         $machine->chdir('..');
         $machine->system('rm -rf mm');
         $machine->system('rm mm.tar.gz');
      },
   );
\end{verbatim}


Con una llamada a \texttt{get\_result} como la que sigue:

\begin{verbatim}
   my $output = $remote->get_result('dat/mm_200');
\end{verbatim}


Obtendriamos en \texttt{\$output} una salida similar. En cambio,
con una llamada a \texttt{save\_result} como esta:

\begin{verbatim}
   $remote->save_result('dat/mm_200', 'test200');
\end{verbatim}


La salida del programa seria almacenada en el fichero
\texttt{test200.base} dentro del directorio definido en la
llamada al constructor como \texttt{BASEDIR}, en la maquina local.

\section{METHODS\label{METHODS}\index{METHODS}}
\subsection*{The constructor \texttt{new}\label{The_constructor_new}\index{The constructor new}}


Vease una llamada tipica:

\begin{verbatim}
   my $remote = Bench::Test::Remote->new(
      HOST       => 'user@some.host.com',
      WORKDIR    => '/home/user/mm',
      EXECUTABLE => 'mm',
      BASEDIR    => './base_somehost',
      OUTPUTFILE => 'output.dat',
      PREAMBLE   => sub { ..preamble code.. },
      POSTAMBLE  => sub { ..postamble code.. },
   );
\end{verbatim}


Este metodo devuelve una nueva instancia de un objeto
de la clase Bench::Test::Remote



El constructor acepta los siguientes parametros:

\begin{description}

\item[{HOST}] \mbox{}

Maquina de destino sobre las que se lanzaran las
ejecuciones. Para un correcto funcionamiento se debe
tener acceso no interactivo mediante clave publica-privada.


\item[{WORKDIR:}] \mbox{}

Directorio de trabajo donde se encuentra 
el ejecutable y desde donde se llevaran a cabo todas las ejecuciones.


\item[{EXECUTABLE:}] \mbox{}

Nombre del fichero ejecutable.


\item[{OUTPUTFILE:}] \mbox{}

Parametro opcional que indica el nombre del fichero
donde se encuentra la salida de la ejecucion del programa. Util en
caso de que el programa no imprima la salida por pantalla.


\item[{BASEDIR:}] \mbox{}

Nombre del directorio donde se creara el fichero \texttt{.base}
generado como consecuencia de la llamada a \texttt{save\_result}.


\item[{PREAMBLE y POSTAMBLE:}] \mbox{}

Puntero a subrutinas que seran llamadas justo despues de
abrir y antes de cerrar la conexion con la maquina remota
respectivamente.



Ambas rutinas reciben como parametro el objeto \texttt{GRID::Machine}
asociado a la maquina remota. Vease la documentacion del modulo
\texttt{GRID::Machine} para conocer sus posibilidades.

\end{description}
\subsection*{The \texttt{get\_result} method\label{The_get_result_method}\index{The get\ result method}}


Vease una llamada tipica:

\begin{verbatim}
  my $parameters = '-n 20 -p';
  my $output = $remote->get_result($parameters);
\end{verbatim}


El metodo get\_result acepta como unico parametro una cadena que
indica los parametros con los que se ejecutara el experimento
indicado en el constructor con el parametro \textbf{EXECUTABLE} en
la maquina remota indicada con el parametro \textbf{HOST}.

\subsection*{The \texttt{save\_result} method\label{The_save_result_method}\index{The save\ result method}}


Vease una llamada tipica:

\begin{verbatim}
  $remote->save_result($parameters, $testname);
\end{verbatim}


El metodo \texttt{save\_result} acepta igual que \texttt{get\_result} una
cadena con los parametros de ejecucion para EXECUTABLE y el
nombre del test correspondiente.



El metodo \texttt{save\_result} automatiza la ejecucion invocando
al metodo \texttt{get\_result} y guarda la salida en un fichero
de texto ubicado en el directorio definido en el constructor
(new) en el parametro BASEDIR. El nombre del archivo se
obtiene concatenando el parametro \textbf{\$testname} con la
extension \textbf{.base}.

\section{SEE ALSO\label{SEE_ALSO}\index{SEE ALSO}}


Bench::Test, Bench::Test::Base, Bench::Test::Local y GRID::Machine module, by Casiano Rodriguez Leon

\section{AUTHOR\label{AUTHOR}\index{AUTHOR}}


Casiano Rodriguez-Leon
Juan Antonio Gomez Cabo



$<$casiano@ull.es$>$
$<$gomezcabo@yahoo.es$>$

\section{COPYRIGHT AND LICENSE\label{COPYRIGHT_AND_LICENSE}\index{COPYRIGHT AND LICENSE}}


Copyright (C) 2006 by Casiano Rodriguez Leon, Juan Antonio Gomez Cabo



This program is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.8.4 or,
at your option, any later version of Perl 5 you may have available.

